package com.ljx.stateMode.after;

import lombok.Data;

/**
 * 状态模式（使用状态模式后的代码），（复杂案例）
 *
 * 定义：
 * 对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为
 *
 * 优点：
 * * 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
 * * 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
 *
 * 缺点：
 * * 状态模式的使用必然会增加系统类和对象的个数。
 * * 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
 * * 状态模式对"开闭原则"的支持并不太好
 *
 * 使用场景：
 * 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
 * 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。
 *
 * @作者 LJX
 * @日期 2022/12/26 10:23
 */
public class StateTestAfterComplex {

    public static void main(String[] args) {
        //创建环境对象
        Context context = new Context();

        context.setUpLifeState(Context.CLOSE_STATE);

        context.open();
        context.run();
        context.close();

        context.stop();

    }

}

/**
 * 环境角色
 */
@Data
class Context{

    //定义出所有电梯状态
    public final static OpenState OPEN_STATE = new OpenState();
    public final static CloseState CLOSE_STATE = new CloseState();
    public final static RunState RUN_STATE = new RunState();
    public final static StopState STOP_STATE = new StopState();

    //当前电梯状态
    private LifeState lifeState;

    public void setUpLifeState(LifeState lifeState){
        //当前状态改变
       this.lifeState = lifeState;
       //把当前的改变通知到各个实现类中
        this.lifeState.setContext(this);
    }

    public void open() {
        lifeState.open();
    }

    public void close() {
        lifeState.close();
    }

    public void run() {
        lifeState.run();
    }

    public void stop() {
        lifeState.stop();
    }

}

/**
 * 抽象状态类
 */
@Data
abstract class LifeState{

    protected Context context;

    //开门
    public abstract void open();
    //关门
    public abstract void close();
    //运行
    public abstract void run();
    //停止
    public abstract void stop();

}

/**
 * 开门状态类
 */
class OpenState extends LifeState{

    @Override
    public void open() {
        System.out.println("已经开门了。。。。");
    }

    @Override
    public void close() {
        //状态修改
        super.context.setUpLifeState(Context.CLOSE_STATE);
        super.context.close();
    }

    @Override
    public void run() {
        //电梯门不能开着就跑，这里什么也不做
    }

    @Override
    public void stop() {
        //开门状态已经是停止的了，所以也什么都不做
    }
}

/**
 * 关门状态类
 */
class CloseState extends LifeState{

    @Override
    public void open() {
        //关门的时候，是可以开门的
        super.context.setUpLifeState(Context.OPEN_STATE);
        super.context.open();
    }

    @Override
    public void close() {
        System.out.println("已经关门了。。。。");
    }

    @Override
    public void run() {
        //关门的时候，是可以运行的
        super.context.setUpLifeState(Context.RUN_STATE);
        super.context.run();
    }

    @Override
    public void stop() {
        //关门的时候，是可以停止的
        super.context.setUpLifeState(Context.STOP_STATE);
        super.context.stop();
    }
}

/**
 * 运行状态类
 */
class RunState extends LifeState{

    @Override
    public void open() {
        //运行的电梯，不可以开门
    }

    @Override
    public void close() {
        //运行的电梯，本来就是关门的
    }

    @Override
    public void run() {
        //电梯已经是运行的了
        System.out.println("电梯正在运行。。。");
    }

    @Override
    public void stop() {
        //运行的时候是可以停止的
        super.context.setUpLifeState(Context.STOP_STATE);
        super.context.stop();
    }
}

/**
 * 关闭状态类
 */
class StopState extends LifeState{

    @Override
    public void open() {
        //停止的状态可以开门
        super.context.setUpLifeState(Context.OPEN_STATE);
        super.context.open();
    }

    @Override
    public void close() {
        //停止的时候，本来就是关门的
    }

    @Override
    public void run() {
        //停止的时候，可以运行
        super.context.setUpLifeState(Context.RUN_STATE);
        super.context.run();
    }

    @Override
    public void stop() {
        //本来就是停止的
        System.out.println("电梯停止了。。。");
    }
}
